package juc2.lock;

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

/**
 * LockInterruptiblyDemo 示例代码
 * 展示了 Lock.lockInterruptibly() 方法的用法与SynchronizedInterruptDemo的区别
 */
public class LockInterruptiblyDemo {
    // 创建一个锁（非公平锁，不影响中断特性）
    private static final ReentrantLock lock = new ReentrantLock();

    public static void main(String[] args) throws InterruptedException {
        // 线程1：先获取锁并持有一段时间
        Thread thread1 = new Thread(() -> {
            try {
                lock.lock();
                System.out.println("线程1：获取到锁，开始执行（将持有5秒）");
                // 持有锁5秒，模拟长时间操作
                Thread.sleep(5000);
            } catch (InterruptedException e) {
                System.out.println("线程1：被中断（但此时已持有锁）");
            } finally {
                if (lock.isHeldByCurrentThread()) {
                    lock.unlock();
                    System.out.println("线程1：释放锁");
                }
            }
        });

        // 线程2：尝试获取锁，若3秒内未获取则被中断
        Thread thread2 = new Thread(() -> {
            try {
                System.out.println("线程2：尝试获取锁（可被中断）");
                // 调用lockInterruptibly()，允许在等待时响应中断
                lock.lockInterruptibly();
                try {
                    System.out.println("线程2：成功获取到锁");
                } finally {
                    lock.unlock();
                    System.out.println("线程2：释放锁");
                }
            } catch (InterruptedException e) {
                // 捕获中断异常，说明在等待锁时被中断
                System.out.println("线程2：在等待锁的过程中被中断，放弃获取");
            }
        });

        // 启动线程1（先获取锁）
        thread1.start();
        // 确保线程1先执行
        Thread.sleep(100);
        // 启动线程2（此时线程1已持有锁，线程2会进入等待）
        thread2.start();

        // 主线程等待3秒后，中断线程2（因为线程2肯定还在等待锁）
        Thread.sleep(3000);
        System.out.println("主线程：中断线程2的等待");
        thread2.interrupt();
    }
}


